/*
 * Copyright (C) 2007 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.vertigo.fever;

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.IntBuffer;

import javax.microedition.khronos.opengles.GL10;

/**
 * A vertex shaded cube.
 */
class TileTriangle extends Tile {

	enum Direction {FWD, BCK, LFT, RHT};
	int colourIndex;
	private IntBuffer mVertexBuffer;
	private IntBuffer mColorBuffer;
	private ByteBuffer mIndexBuffer;
	private Direction direction;
	
	public TileTriangle(int colourIndex, char code, Direction direction ) {
		super(code);
		this.direction = direction;
		this.colourIndex = colourIndex;
		int one = 0x10000;
		int x = 0x10000;
		int y = 0x1000;
		int z = 0x10000;
		
		int pr = direction==Direction.RHT?0:1; 
		int pl = direction==Direction.LFT?0:1; 
		int pf = direction==Direction.FWD?0:1;
		
		int vertices[] = { -x*pf, -y, -z*pr,  x*pf, -y, -z*pl,  x*pf, y, -z*pl,  -x*pf, y, -z*pr, 
				           -x, -y, z*pr,   x, -y, z*pl,   x, y, z*pl,   -x, y, z*pr, };
   

		int[][] colors = { generateColorGrid(one, 0, 0, 0, one, 0),
				generateColorGrid(0, 0, one, 0, one, 0),
				generateColorGrid(one, 0, one, 0, one, 0),
				generateColorGrid(one, one, 0, 0, one, 0),
				generateColorGrid(0, one, one, 0, one, 0),
				generateColorGrid(one, one, one, 0, one, 0), };

		byte indices[] = { 0, 4, 5, 0, 5, 1, 1, 5, 6, 1, 6, 2, 2, 6, 7, 2, 7,
				3, 3, 7, 4, 3, 4, 0, 4, 7, 6, 4, 6, 5, 3, 0, 1, 3, 1, 2 };

		// Buffers to be passed to gl*Pointer() functions
		// must be direct, i.e., they must be placed on the
		// native heap where the garbage collector cannot
		// move them.
		//
		// Buffers with multi-byte datatypes (e.g., short, int, float)
		// must have their byte order set to native order

		ByteBuffer vbb = ByteBuffer.allocateDirect(vertices.length * 4);
		vbb.order(ByteOrder.nativeOrder());
		mVertexBuffer = vbb.asIntBuffer();
		mVertexBuffer.put(vertices);
		mVertexBuffer.position(0);

		ByteBuffer cbb = ByteBuffer
				.allocateDirect(colors[colourIndex].length * 4);
		cbb.order(ByteOrder.nativeOrder());
		mColorBuffer = cbb.asIntBuffer();
		mColorBuffer.put(colors[colourIndex]);
		mColorBuffer.position(0);

		mIndexBuffer = ByteBuffer.allocateDirect(indices.length);
		mIndexBuffer.put(indices);
		mIndexBuffer.position(0);

	}

	public int[] generateColorGrid(int red1, int green1, int blue1, int red2,
			int green2, int blue2) {

		return new int[] { red1, green1, blue1, 0, red1, green1, blue1, 0,
				red1, green1, blue1, 0, red1, green1, blue1, 0, red2, green2,
				blue2, 0, red2, green2, blue2, 0, red2, green2, blue2, 0, red2,
				green2, blue2, 0, };
	}

	public void draw(GL10 gl) {
		gl.glFrontFace(gl.GL_CW);
		gl.glVertexPointer(3, gl.GL_FIXED, 0, mVertexBuffer);
		gl.glColorPointer(4, gl.GL_FIXED, 0, mColorBuffer);
		gl.glDrawElements(gl.GL_TRIANGLES, 36, gl.GL_UNSIGNED_BYTE,
				mIndexBuffer);

	}
}
